
package ajedrez;

public class clsCalculaHeuristica {

    final int TOPE_TABLERO=128;

    public static final float VAL_PEON = 25;
    public static final float VAL_CABALLO = 75;
    public static final float VAL_ALFIL = 77.5f;
    public static final float VAL_TORRE = 125;
    public static final float VAL_DAMA = 225;
    public static final float VAL_REY = 100;

    public clsCalculaHeuristica()
    {

    }


    /*
     *
     * Capturar Posición del Rey Blanco: xRB,  yRB
        2°  Capturar Posición del Rey Negro: xRN, yRN
        3°  Sumar N° de piezas Blancas: sumaB
        4°  Sumar N° de piezas Negras: sumaN
        5°  Calcular que tan protegido esta el rey blanco de las
        piezas negras: BRP
        6°  Calcular que tan Protegido esta el rey Negro de las
        piezas blancas: NRP
        7°  Calcular que tan cerca están las piezas negras del rey
        Blanco: BAR
        8°  Calcular que tan cerca están las piezas blancas del rey
        Negro: NAR
     */
    public float getReinaBlancaViva(Tablero tab)
    {
        for(int i=0;i<tab.Juego.length;i++)
        {
             if((i & 136)==0)
             {
                 if(tab.Juego[i]==6)
                     return (float)0.20;
             }
        }
         return (float)-0.20;
    }
    public float getReinaNegraViva(Tablero tab)
    {
        for(int i=0;i<tab.Juego.length;i++)
        {
             if((i & 136)==0)
             {
                 if(tab.Juego[i]==-6)
                     return (float)0.20;
             }
        }
         return (float)-0.20;
    }
    public int getPosReyBlanco(Tablero tab)
    {
        //busco un 6
        int Posicion=-1;
        for(int x=0;x<TOPE_TABLERO;x++)
         if(tab.Juego[x]==6)
         {
             Posicion = x;
             x=TOPE_TABLERO;
         }
        return Posicion;
    }
    public int getPosReyNegro(Tablero tab)
    {
         int Posicion=-1;
        for(int x=0;x<TOPE_TABLERO;x++)
         if(tab.Juego[x]==-6)
         {
             Posicion = x;
             x=TOPE_TABLERO;
         }
        return Posicion;
    }

    /*
    //Esta función devuelve la heuristica para un tablero dado
    //el int jugador representa a: 1 tiro pieza blanca, -1 tiro pieza negra
    public float CalculaHeuristica(Tablero tab,int jugador)
    {
        float Heuristica=0;
        try{

            if((CantPiezasBlancas(tab)!=CantPiezasNegras(tab)))
            Heuristica =(float)(CantPiezasBlancas(tab)-CantPiezasNegras(tab))/(CantPiezasBlancas(tab)+ CantPiezasNegras(tab)) ;
//            else
//               Heuristica=Heuristica-(float)0.20;

            }
            catch(Exception ex)
            {

            }
            try{
             Heuristica += (ProtegidoReyBlanco(tab,getPosReyBlanco(tab))-ProtegidoReyNegro(tab,getPosReyNegro(tab)))/(ProtegidoReyBlanco(tab,getPosReyBlanco(tab))+ProtegidoReyNegro(tab,getPosReyNegro(tab))) ;
            }
            catch(Exception ex)
            {

            }
            try{
             Heuristica +=(float)((CalcCercaniaRblanco(tab,getPosReyBlanco(tab))-CalcCercaniaRnegro(tab,getPosReyNegro(tab)))*-1)/(CalcCercaniaRblanco(tab,getPosReyBlanco(tab))+CalcCercaniaRnegro(tab,getPosReyNegro(tab)));
            }
             catch(Exception ex)
            {

            }
            try{
          //   Heuristica+=CantNegrosPeonesMovidos(tab)-CantBlancosPeonesMovidos(tab);
            }
             catch(Exception ex)
            {

            }

       //  Heuristica+=(float)(getReinaBlancaViva(tab)-getReinaNegraViva(tab));
//          Heuristica+=(float)(CantAVBlancos(tab)-CantAVNegros(tab));
//          Heuristica+=(float)(CantCabBlancos(tab)-CantCabNegros(tab));
//          Heuristica+=(float)(CantTorresBlancas(tab)-CantTorresNegras(tab));

        Heuristica=Heuristica*100;
        if(jugador==-1)
        {
           Heuristica =  Heuristica*(-1);
        }

         return Heuristica;

    }
     */

    //Esta función devuelve la heuristica para un tablero dado
    //el int jugador representa a: 1 tiro pieza blanca, -1 tiro pieza negra
    public float CalculaHeuristica(Tablero tab,int jugador)
    {
        float vfTotal = 0;
        float vfSeguridadRey = 0;
        float vfBalanceMaterial = 0;

        vfSeguridadRey = this.SeguridadDelRey(tab, jugador);
        vfBalanceMaterial = this.BalanceMaterial(tab, jugador);

        vfTotal = vfSeguridadRey + vfBalanceMaterial;
        //vfTotal = vfSeguridadRey;
        //vfTotal = vfBalanceMaterial;

        //Tablero.ImprimirTablero(tab.Juego);
        //System.out.println("Total: " + vfTotal + ", Balance: " + vfBalanceMaterial + ", Seguridad: " + vfSeguridadRey);
        
        return vfTotal;
    }


    private float BalanceMaterial(Tablero pConfigTablero,int pJugador)
    {
        float vfEquilibrio = 0;
        float vfNegras = 0;
        float vfBlancas = 0;

        vfNegras += ValorPieza(pConfigTablero, Tablero.NEGRAS, Tablero.PEON);
        vfNegras += ValorPieza(pConfigTablero, Tablero.NEGRAS, Tablero.CABALLO);
        vfNegras += ValorPieza(pConfigTablero, Tablero.NEGRAS, Tablero.ALFIL);
        vfNegras += ValorPieza(pConfigTablero, Tablero.NEGRAS, Tablero.TORRE);
        vfNegras += ValorPieza(pConfigTablero, Tablero.NEGRAS, Tablero.DAMA);
        vfNegras += ValorPieza(pConfigTablero, Tablero.NEGRAS, Tablero.REY);

        vfBlancas += ValorPieza(pConfigTablero, Tablero.BLANCAS, Tablero.PEON);
        vfBlancas += ValorPieza(pConfigTablero, Tablero.BLANCAS, Tablero.CABALLO);
        vfBlancas += ValorPieza(pConfigTablero, Tablero.BLANCAS, Tablero.ALFIL);
        vfBlancas += ValorPieza(pConfigTablero, Tablero.BLANCAS, Tablero.TORRE);
        vfBlancas += ValorPieza(pConfigTablero, Tablero.BLANCAS, Tablero.DAMA);
        vfBlancas += ValorPieza(pConfigTablero, Tablero.BLANCAS, Tablero.REY);

        if(pJugador == Tablero.NEGRAS)
            vfEquilibrio = vfBlancas - vfNegras;
        else
            vfEquilibrio = vfNegras - vfBlancas;
        
        return vfEquilibrio;
    }


    private float SeguridadDelRey(Tablero tab,int jugador)
    {
        float Heuristica=0;
        try{

            if((CantPiezasBlancas(tab)!=CantPiezasNegras(tab)))
            Heuristica =(float)(CantPiezasBlancas(tab)-CantPiezasNegras(tab))/(CantPiezasBlancas(tab)+ CantPiezasNegras(tab)) ;
//            else
//               Heuristica=Heuristica-(float)0.20;

            }
            catch(Exception ex)
            {

            }
            try{
             Heuristica += (ProtegidoReyBlanco(tab,getPosReyBlanco(tab))-ProtegidoReyNegro(tab,getPosReyNegro(tab)))/(ProtegidoReyBlanco(tab,getPosReyBlanco(tab))+ProtegidoReyNegro(tab,getPosReyNegro(tab))) ;
            }
            catch(Exception ex)
            {

            }
//            try{
//             Heuristica +=(float)((CalcCercaniaRblanco(tab,getPosReyBlanco(tab))-CalcCercaniaRnegro(tab,getPosReyNegro(tab)))*-1)/(CalcCercaniaRblanco(tab,getPosReyBlanco(tab))+CalcCercaniaRnegro(tab,getPosReyNegro(tab)));
//            }
//             catch(Exception ex)
//            {
//
//            }
            try{
             Heuristica+=CantBlancosPeonesMovidos(tab)-CantNegrosPeonesMovidos(tab);
            }
             catch(Exception ex)
            {

            }

         Heuristica+=(float)(getReinaBlancaViva(tab)-getReinaNegraViva(tab));
     Heuristica+=(float)(CantAVBlancos(tab)-CantAVNegros(tab))/(CantAVBlancos(tab)+CantAVNegros(tab));
          Heuristica+=(float)(CantCabBlancos(tab)-CantCabNegros(tab));
          Heuristica+=(float)(CantTorresBlancas(tab)-CantTorresNegras(tab));

        Heuristica=Heuristica*100;
        if(Heuristica<1)
        {
           Heuristica =  Heuristica*(-1);
        }

         return Heuristica;
    }


    public float ValorPieza(Tablero pConfigTablero, int pJugador, int pPieza)
    {
        int viCantidad = 0;
        float CentiPawn = 0;

        for(int i = 0; i <= Tablero.TamanioTablero ;i++)
        {
            if((i & Tablero.PATRON)==0)
            {
                if(pConfigTablero.Juego[i] == (pPieza * pJugador))
                    viCantidad++;
            }
        }

        if(pPieza == Tablero.PEON)
            CentiPawn = viCantidad * VAL_PEON;
        else if(pPieza == Tablero.CABALLO)
            CentiPawn = viCantidad * VAL_CABALLO;
        else if(pPieza == Tablero.ALFIL)
            CentiPawn = viCantidad * VAL_ALFIL;
        else if(pPieza == Tablero.TORRE)
            CentiPawn = viCantidad * VAL_TORRE;
        else if(pPieza == Tablero.DAMA)
            CentiPawn = viCantidad * VAL_DAMA;
        else if(pPieza == Tablero.REY)
            CentiPawn = viCantidad * VAL_REY;
        
        return CentiPawn;
    }

    public float CantBlancosPeonesMovidos(Tablero tab)
    {
        float peones=0;
        for(int i=64; i<=87 ;i++)
        {
            if((i & 136)==0)
            {
                if(tab.Juego[i]==1)
                    peones++;
            }
        }
        peones=(float) (peones * 0.02);
        return peones;
    }
    public float CantNegrosPeonesMovidos(Tablero tab)
    {
        float peones=0;
        for(int i=64; i<=87 ;i++)
        {
            if((i & 136)==0)
            {
                if(tab.Juego[i]==-1)
                    peones++;
            }
        }
        peones=(float) (peones * 0.02);
        return peones;
    }
    public float ProtegidoReyBlanco(Tablero tab,int posBlanco)
    {
       float cercania = 0;
         int nivel=0;//numero de fila
         int [] cantNivel=new int[6];
         float [] promedio=new float[8];
         LimpiarArray(cantNivel);
         //1) calcular la cercania en la parte inferior del rey (vertical)
         //verificar si hay fichas abajo del rey
         int posicionFAbajo=posBlanco+16;
         if(posicionFAbajo<tab.Juego.length)
         {
             for (int i = posicionFAbajo;i<tab.Juego.length && (i & 136)==0;i=i+16 )
             {
                 if(tab.Juego[i]>0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[0]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[0]=promedio[0]/nivel;

         }
         //2) calcular la cercania en la parte superior al rey (vertical)
          int posicionFArriba=posBlanco-16;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionFArriba>0)
         {
             for (int i = posicionFArriba;i>0 && (i & 136)==0;i=i-16 )
             {
                 if(tab.Juego[i]>0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[1]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[1]=promedio[1]/nivel;
         }

         //3) calcular la cercania en la parte izquierda al rey (horizontal)
          int posicionCIzq=posBlanco-1;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionCIzq>0)
         {
             for (int i = posicionCIzq;i>0 && (i & 136)==0;i=i-1 )
             {
                 if(tab.Juego[i]>0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[2]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[2]=promedio[2]/nivel;
         }
          //4) calcular la cercania en la parte derecha al rey (horizontal)
          int posicionCDer=posBlanco+1;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionCDer<tab.Juego.length)
         {
             for (int i = posicionCDer;i<tab.Juego.length && (i & 136)==0;i=i+1 )
             {
                 if(tab.Juego[i]>0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[3]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[3]=promedio[3]/nivel;
         }
           //5) calcular la cercania en la parte izquierda superior al rey
          int posicionDiagIzqSup=posBlanco-17;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionDiagIzqSup>0)
         {
             for (int i = posicionDiagIzqSup;i>0 && (i & 136)==0;i=i-17 )
             {
                 if(tab.Juego[i]>0)
                cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[4]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[4]=promedio[4]/nivel;
         }
           //6) calcular la cercania en la parte izquierda inferior al rey
          int posicionDiagIzqInf=posBlanco+15;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionDiagIzqInf<tab.Juego.length)
         {
             for (int i = posicionDiagIzqInf;i<tab.Juego.length && (i & 136)==0;i=i+15 )
             {
                 if(tab.Juego[i]>0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[5]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[5]=promedio[5]/nivel;
         }
           //7) calcular la cercania en la parte derecha inferior al rey (horizontal)
          int posicionDiagDerInf=posBlanco+17;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionDiagDerInf<tab.Juego.length)
         {
             for (int i = posicionDiagDerInf;i<tab.Juego.length && (i & 136)==0;i=i+17 )
             {
                 if(tab.Juego[i]>0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[6]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[6]=promedio[6]/nivel;
         }
         //8) calcular la cercania en la parte derecha inferior al rey
          int posicionDiagDerSup=posBlanco-15;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionDiagDerSup>0)
         {
             for (int i = posicionDiagDerSup;i>0 && (i & 136)==0;i=i-15 )
             {
                 if(tab.Juego[i]>0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[7]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[7]=promedio[7]/nivel;
         }

         //Calculo de cercania
          for(int i=0;i<promedio.length;i++)
          {
              cercania+=promedio[i];
          }
          cercania=cercania/promedio.length;
         return cercania;

    }
     public float ProtegidoReyNegro(Tablero tab,int posNegro)
    {
       float cercania = 0;
         int nivel=0;//numero de fila
         int [] cantNivel=new int[6];
         float [] promedio=new float[8];
         LimpiarArray(cantNivel);
         //1) calcular la cercania en la parte inferior del rey (vertical)
         //verificar si hay fichas abajo del rey
         int posicionFAbajo=posNegro+16;
         if(posicionFAbajo<tab.Juego.length)
         {
             for (int i = posicionFAbajo;i<tab.Juego.length && (i & 136)==0;i=i+16 )
             {
                 if(tab.Juego[i]<0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[0]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[0]=promedio[0]/nivel;

         }
         //2) calcular la cercania en la parte superior al rey (vertical)
          int posicionFArriba=posNegro-16;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionFArriba>0)
         {
             for (int i = posicionFArriba;i>0 && (i & 136)==0;i=i-16 )
             {
                 if(tab.Juego[i]<0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[1]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[1]=promedio[1]/nivel;
         }

         //3) calcular la cercania en la parte izquierda al rey (horizontal)
          int posicionCIzq=posNegro-1;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionCIzq>0)
         {
             for (int i = posicionCIzq;i>0 && (i & 136)==0;i=i-1 )
             {
                 if(tab.Juego[i]<0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[2]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[2]=promedio[2]/nivel;
         }
          //4) calcular la cercania en la parte derecha al rey (horizontal)
          int posicionCDer=posNegro+1;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionCDer<tab.Juego.length)
         {
             for (int i = posicionCDer;i<tab.Juego.length && (i & 136)==0;i=i+1 )
             {
                 if(tab.Juego[i]<0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[3]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[3]=promedio[3]/nivel;
         }
           //5) calcular la cercania en la parte izquierda superior al rey
          int posicionDiagIzqSup=posNegro-17;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionDiagIzqSup>0)
         {
             for (int i = posicionDiagIzqSup;i>0 && (i & 136)==0;i=i-17 )
             {
                 if(tab.Juego[i]<0)
                cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[4]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[4]=promedio[4]/nivel;
         }
           //6) calcular la cercania en la parte izquierda inferior al rey
          int posicionDiagIzqInf=posNegro+15;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionDiagIzqInf<tab.Juego.length)
         {
             for (int i = posicionDiagIzqInf;i<tab.Juego.length && (i & 136)==0;i=i+15 )
             {
                 if(tab.Juego[i]<0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[5]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[5]=promedio[5]/nivel;
         }
           //7) calcular la cercania en la parte derecha inferior al rey (horizontal)
          int posicionDiagDerInf=posNegro+17;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionDiagDerInf<tab.Juego.length)
         {
             for (int i = posicionDiagDerInf;i<tab.Juego.length && (i & 136)==0;i=i+17 )
             {
                 if(tab.Juego[i]<0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[6]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[6]=promedio[6]/nivel;
         }
         //8) calcular la cercania en la parte derecha inferior al rey
          int posicionDiagDerSup=posNegro-15;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionDiagDerSup>0)
         {
             for (int i = posicionDiagDerSup;i>0 && (i & 136)==0;i=i-15 )
             {
                 if(tab.Juego[i]<0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[7]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[7]=promedio[7]/nivel;
         }

         //Calculo de cercania
          for(int i=0;i<promedio.length;i++)
          {
              cercania+=promedio[i];
          }
          cercania=cercania/promedio.length;
         return cercania;
    }
     private void LimpiarArray(int[] Array)
    {
         for(int i=0;i<Array.length;i++)
             Array[i]=0;
     }
     public float CalcCercaniaRblanco(Tablero tab,int posBlanco)
     {
         float cercania = 0;
         int nivel=0;//numero de fila
         int [] cantNivel=new int[6];
         float [] promedio=new float[8];
         LimpiarArray(cantNivel);
         //1) calcular la cercania en la parte inferior del rey (vertical)
         //verificar si hay fichas abajo del rey
         int posicionFAbajo=posBlanco+16;
         if(posicionFAbajo<tab.Juego.length)
         {
             for (int i = posicionFAbajo;(i<tab.Juego.length && (i & 136)==0);i=i+16 )
             {
                 if(tab.Juego[i]<0)
                    cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[0]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[0]=promedio[0]/nivel;

         }
         //2) calcular la cercania en la parte superior al rey (vertical)
          int posicionFArriba=posBlanco-16;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionFArriba>0)
         {
             for (int i = posicionFArriba;i>0 && (i & 136)==0;i=i-16 )
             {
                 if(tab.Juego[i]<0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[1]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[1]=promedio[1]/nivel;
         }

         //3) calcular la cercania en la parte izquierda al rey (horizontal)
          int posicionCIzq=posBlanco-1;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionCIzq>0)
         {
             for (int i = posicionCIzq;i>0 && (i & 136)==0;i=i-1 )
             {
                 if(tab.Juego[i]<0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[2]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[2]=promedio[2]/nivel;
         }
          //4) calcular la cercania en la parte derecha al rey (horizontal)
          int posicionCDer=posBlanco+1;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionCDer<tab.Juego.length)
         {
             for (int i = posicionCDer;i<tab.Juego.length && (i & 136)==0;i=i+1 )
             {
                 if(tab.Juego[i]<0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[3]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[3]=promedio[3]/nivel;
         }
           //5) calcular la cercania en la parte izquierda superior al rey
          int posicionDiagIzqSup=posBlanco-17;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionDiagIzqSup>0)
         {
             for (int i = posicionDiagIzqSup;i>0 && (i & 136)==0;i=i-17 )
             {
                 if(tab.Juego[i]<0)
                cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[4]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[4]=promedio[4]/nivel;
         }
           //6) calcular la cercania en la parte izquierda inferior al rey
          int posicionDiagIzqInf=posBlanco+15;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionDiagIzqInf<tab.Juego.length)
         {
             for (int i = posicionDiagIzqInf;i<tab.Juego.length && (i & 136)==0;i=i+15 )
             {
                 if(tab.Juego[i]<0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[5]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[5]=promedio[5]/nivel;
         }
           //7) calcular la cercania en la parte derecha inferior al rey (horizontal)
          int posicionDiagDerInf=posBlanco+17;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionDiagDerInf<tab.Juego.length)
         {
             for (int i = posicionDiagDerInf;i<tab.Juego.length && (i & 136)==0;i=i+17 )
             {
                 if(tab.Juego[i]<0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[6]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[6]=promedio[6]/nivel;
         }
         //8) calcular la cercania en la parte derecha inferior al rey
          int posicionDiagDerSup=posBlanco-15;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionDiagDerSup>0)
         {
             for (int i = posicionDiagDerSup;i>0 && (i & 136)==0;i=i-15 )
             {
                 if(tab.Juego[i]<0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[7]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[7]=promedio[7]/nivel;
         }

         //Calculo de cercania
          for(int i=0;i<promedio.length;i++)
          {
              cercania+=promedio[i];
          }
          cercania=cercania/promedio.length;
         return cercania;
     }
      public float CalcCercaniaRnegro(Tablero tab,int posNegro)
     {
        float cercania = 0;
         int nivel=0;//numero de fila
         int [] cantNivel=new int[6];
         float [] promedio=new float[8];
         LimpiarArray(cantNivel);
         //1) calcular la cercania en la parte inferior del rey (vertical)
         //verificar si hay fichas abajo del rey
         int posicionFAbajo=posNegro+16;
         if(posicionFAbajo<tab.Juego.length)
         {
             for (int i = posicionFAbajo;i<tab.Juego.length && (i & 136)==0;i=i+16 )
             {
                 if(tab.Juego[i]>0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[0]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[0]=promedio[0]/nivel;

         }
         //2) calcular la cercania en la parte superior al rey (vertical)
          int posicionFArriba=posNegro-16;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionFArriba>0)
         {
             for (int i = posicionFArriba;i>0 && (i & 136)==0;i=i-16 )
             {
                 if(tab.Juego[i]>0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[1]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[1]=promedio[1]/nivel;
         }

         //3) calcular la cercania en la parte izquierda al rey (horizontal)
          int posicionCIzq=posNegro-1;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionCIzq>0)
         {
             for (int i = posicionCIzq;i>0 && (i & 136)==0;i=i-1 )
             {
                 if(tab.Juego[i]>0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[2]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[2]=promedio[2]/nivel;
         }
          //4) calcular la cercania en la parte derecha al rey (horizontal)
          int posicionCDer=posNegro+1;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionCDer<tab.Juego.length)
         {
             for (int i = posicionCDer;i<tab.Juego.length && (i & 136)==0;i=i+1 )
             {
                 if(tab.Juego[i]>0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[3]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[3]=promedio[3]/nivel;
         }
           //5) calcular la cercania en la parte izquierda superior al rey
          int posicionDiagIzqSup=posNegro-17;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionDiagIzqSup>0)
         {
             for (int i = posicionDiagIzqSup;i>0 && (i & 136)==0;i=i-17 )
             {
                 if(tab.Juego[i]>0)
                cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[4]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[4]=promedio[4]/nivel;
         }
           //6) calcular la cercania en la parte izquierda inferior al rey
          int posicionDiagIzqInf=posNegro+15;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionDiagIzqInf<tab.Juego.length)
         {
             for (int i = posicionDiagIzqInf;i<tab.Juego.length && (i & 136)==0;i=i+15 )
             {
                 if(tab.Juego[i]>0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[5]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[5]=promedio[5]/nivel;
         }
           //7) calcular la cercania en la parte derecha inferior al rey (horizontal)
          int posicionDiagDerInf=posNegro+17;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionDiagDerInf<tab.Juego.length)
         {
             for (int i = posicionDiagDerInf;i<tab.Juego.length && (i & 136)==0;i=i+17 )
             {
                 if(tab.Juego[i]>0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[6]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[6]=promedio[6]/nivel;
         }
         //8) calcular la cercania en la parte derecha inferior al rey
          int posicionDiagDerSup=posNegro-15;
           LimpiarArray(cantNivel);
          nivel=0;
         if(posicionDiagDerSup>0)
         {
             for (int i = posicionDiagDerSup;i>0 && (i & 136)==0;i=i-15 )
             {
                 if(tab.Juego[i]>0)
                 cantNivel[nivel]++;
                 nivel++;

             }
             for(int i=0;i<cantNivel.length;i++)
             {
                 promedio[7]+=cantNivel[i];
             }
             if(nivel>0)
             promedio[7]=promedio[7]/nivel;
         }

         //Calculo de cercania
          for(int i=0;i<promedio.length;i++)
          {
              cercania+=promedio[i];
          }
          cercania=cercania/promedio.length;
         return cercania;
     }
      public int CantPiezasBlancas(Tablero tab)
    {
          int Contador=0;
          for(int i=0;i<TOPE_TABLERO;i++)
          {
              if(tab.Juego[i]>0)
                  Contador++;
          }
          return Contador;
    }
      public int CantPiezasNegras(Tablero tab)
    {
         int Contador=0;
          for(int i=0;i<TOPE_TABLERO;i++)
          {
              if(tab.Juego[i]<0)
                  Contador++;
          }
          return Contador;
    }
    public int ReinaBlancaViva(Tablero tab)
    {
          for(int i=0;i<TOPE_TABLERO;i++)
          {
              if(tab.Juego[i]==5)
                 return 1;
          }
          return 0;
    }
    public int ReinaNegraViva(Tablero tab)
    {
          for(int i=0;i<TOPE_TABLERO;i++)
          {
              if(tab.Juego[i]==-5)
                 return 1;
          }
          return 0;
    }
    public float CantAVBlancos(Tablero tab)
    {
        float sum=0;
        for(int i=0;i<TOPE_TABLERO;i++)
          {
              if(tab.Juego[i]==3)
                sum++;
          }
          return sum/10;
    }
     public float CantAVNegros(Tablero tab)
    {
        float sum=0;
        for(int i=0;i<TOPE_TABLERO;i++)
          {
              if(tab.Juego[i]==-3)
                sum++;
          }
          return sum/10;
    }
      public float CantTorresBlancas(Tablero tab)
    {
        float sum=0;
        for(int i=0;i<TOPE_TABLERO;i++)
          {
              if(tab.Juego[i]==4)
                sum++;
          }
         return sum/10;
    }
        public float CantTorresNegras(Tablero tab)
    {
        float sum=0;
        for(int i=0;i<TOPE_TABLERO;i++)
          {
              if(tab.Juego[i]==-4)
                sum++;
          }
        return sum/10;

    }

        public float CantCabBlancos(Tablero tab)
    {
        float sum=0;
        for(int i=0;i<TOPE_TABLERO;i++)
          {
              if(tab.Juego[i]==2)
                sum++;
          }
          return sum/10;
    }

        public float CantCabNegros(Tablero tab)
    {
        float sum=0;
        for(int i=0;i<TOPE_TABLERO;i++)
          {
              if(tab.Juego[i]==-2)
                sum++;
          }
          return sum/10;
    }


}
